if dry_run:
        console.print("\n[bold]Dry-run complete[/bold]")
        for _item in _pipeline_session.fix_queue:
            if _item.diff:
                console.print(
                    f"\n  [cyan]{_item.file_path}:{_item.line_number}[/cyan] {_item.message}"
                )
                console.print(_item.diff)
    else:
        console.print(f"\n[bold green]Applied:[/bold green]  {_applied}")
        if _blocked:
            console.print(f"[bold red]Blocked:[/bold red]  {_blocked}")
        if _skipped:
            console.print(f"[dim]Skipped:  {_skipped}[/dim]")
        console.print(f"\n[dim]Session: {_pipeline_session.session_id}[/dim]")
        if _applied > 0:
            console.print(
                f"[dim]To undo: refactron rollback --session "
                f"{_pipeline_session.session_id}[/dim]"
            )
    return

    # Setup
    target_path = _validate_path(target)
    _load_config(config, profile, environment)
    _print_file_count(target_path)

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@refactron/cli/refactor.py`:
- Around line 350-353: The rollback hint prints the wrong flag; update the
string passed to console.print in the blocks that check _applied > 0 (and the
similar block around lines 432-437) to use the new flag name --pipeline-session
instead of --session so the hint points users to the pipeline rollback path;
locate the console.print calls that reference _pipeline_session.session_id and
replace the embedded "--session" token with "--pipeline-session" so the printed
undo command matches the implemented CLI option.
- Around line 300-307: The session/backup lookup is using the caller's CWD
instead of the pipeline's project root; update the code that constructs
SessionStore and BackupManager and the session-loading logic to derive
project_root the same way RefactronPipeline does (use the
_target_path/_project_root logic used when instantiating RefactronPipeline or
use PipelineSession.target when resuming), so SessionStore.load(session_id) and
BackupManager operate against the pipeline's project_root rather than
Path.cwd(); apply the same change to the other affected block referenced (around
the code handling rollback / lines 461-478) so all session and backup resolution
consistently uses RefactronPipeline.project_root or PipelineSession.target.

In `@refactron/cli/run.py`:
- Around line 35-40: The CLI currently performs destructive changes by default;
change the click option for "--dry-run" to default=True (so preview is the
default) and remove the unconditional call to pipeline.apply(... dry_run=False)
in the run command; instead call a non-destructive pipeline.preview(...) after
analysis, and only invoke pipeline.backup(...) then pipeline.apply(...) when an
explicit confirmation/flag (e.g. an "--apply" or interactive yes prompt) is
provided; ensure the flow follows preview → backup → apply → optional rollback
and reference the existing pipeline.apply and pipeline.preview calls in run.py
so the code only writes files when the explicit apply path is taken.
- Around line 120-129: The fail-on check uses stale counts in
session.issues_by_level from the pre-apply analysis; after calling
pipeline.apply() you must recompute severity totals before evaluating --fail-on.
Update the code so that once pipeline.apply() completes you invoke the session
analysis routine that refreshes issue counts (e.g. call the method that re-runs
analysis or recomputes totals on session such that session.issues_by_level is
updated), then compute threshold via _LEVEL_RANK[fail_on.upper()] and evaluate
should_fail against the refreshed session.issues_by_level and raise
SystemExit(1) if appropriate.

In `@refactron/cli/status.py`:
- Around line 27-30: Wrap calls to SessionStore.list_sessions() and
SessionStore.load() in try/except at the CLI boundary (in the status command) so
any IO/Unicode/parse errors from unreadable or non-UTF8 files under
.refactron/sessions/ are caught; catch broad exceptions like
OSError/UnicodeDecodeError/ValueError (or Exception as a last resort), and print
a concise, friendly error message via the CLI logger/console instead of letting
the traceback propagate, then return a non-zero exit code. Locate the calls to
SessionStore.list_sessions() and SessionStore.load() in the status command and
add the try/except blocks around them, ensuring the error message references the
sessions directory/context so users know which file caused the problem.

In `@refactron/core/pipeline_session.py`:
- Around line 149-152: The save() implementation writes session JSON in-place
which can produce a truncated/corrupt newest file; change save(session:
PipelineSession) to write to a temporary file in the same directory (e.g.,
_session_path(session.session_id).with_suffix(".tmp")), flush and fsync the temp
file, then atomically rename/move it to the final path; reference
session.to_dict(), sessions_dir and _session_path. Update load_latest() to not
assume the single lexicographically newest file is valid: list files in
sessions_dir sorted descending, attempt to open and json.loads each in order,
returning the first successfully parsed PipelineSession (skip malformed files
and continue), and only return None if none parse successfully.
- Around line 146-147: Treat the session_id as untrusted data: validate it in
_session_path and any callers (reject if it contains path separators '/' or '\\'
or the segment '..', or use a strict allowlist/sanitization), and when loading a
session (the load() code that reads the JSON) verify the parsed object's
session_id exactly equals the requested session_id and raise an error if not;
ensure all places that build paths from session_id use _session_path so the
validation is centralized and the code fails closed on mismatches or invalid
ids.
- Around line 142-145: The constructor SessionStore.__init__ is missing a return
type annotation which violates disallow_untyped_defs; update the method
signature in class SessionStore (def __init__(self, root_dir: Optional[Path] =
None)) to include an explicit -> None return annotation, and ensure Optional and
Path are imported/available in that module so the type hint resolves.

In `@refactron/core/pipeline.py`:
- Around line 136-174: Before applying fixes when not dry_run, create the backup
session (backup_manager.create_backup_session) and then back up each target file
into that session prior to calling fix_engine.fix_file; after backing files,
call BackupManager.validate_backup_integrity(session.backup_session_id) and if
it returns any corrupt_paths mark all related FixItems as BLOCKED (set
block_reason) and append them to session.blocked_fixes, then skip applying fixes
for those files. Ensure when setting item.backup_path you point to
backup_manager.backup_dir / session.backup_session_id / file_path.name and only
proceed to call fix_engine.fix_file(file_path, ...) if the backup validation
succeeded.
- Around line 96-118: queue_issues() currently probes fixers using a synthetic
snippet and stores minimal info in FixQueueItem, and apply() rebuilds a generic
CodeIssue causing loss of original identity; change FixQueueItem to persist the
original issue payload (rule_id, category, metadata, full message, etc.) and
have _find_fixer_name call each fixer's preview against the real file contents
(load the file at issue.file_path) instead of "x = 1\n"; ensure apply()
reconstructs the CodeIssue from the stored original payload (not as
IssueCategory.COMPLEXITY) before calling AutoFixEngine.fix_file(), so
AutoFixEngine.fix_file() receives the original issue with correct
rule_id/metadata and previews are based on actual file text.

---

Outside diff comments:
In `@refactron/cli/refactor.py`:
- Around line 241-262: The early-return branch bypasses the safety-first flow so
options like --preview/--apply, --safety-level, --config, --profile,
--environment and --dry-run are ignored and pipeline.apply() can write files;
change the branch that currently returns to instead funnel through the existing
safety pipeline (preview → backup → pipeline.apply() → optional rollback) so
that --preview causes only a preview (no writes) and pipeline.apply() respects
dry_run and safety-level/config/profile/environment and that verify is run prior
to apply; locate and update the code around the branch that returns (the block
referencing pipeline.apply(), --preview/--apply, --dry-run, --safety-level, and
--verify) to remove the premature return and invoke the common safety handlers
(preview handling, backup creation, apply call, and rollback path) so all
refactors use the same safety-first sequence.

---

Nitpick comments:
In `@tests/test_cli_run.py`:
- Around line 31-38: The tests currently set mock_pipeline._last_result = None
so run() always skips queue_issues() and pipeline.apply(); change the mocks for
RefactronPipeline in tests/test_cli_run.py to populate
mock_pipeline._last_result with a dict containing file_metrics (e.g.
{'file_metrics': [...]}), call runner.invoke(run, ...) as before, and add
assertions that mock_pipeline.queue_issues was called and mock_pipeline.apply
was invoked (or not depending on flags) to ensure the one-shot path is
exercised; update the other two test blocks (lines corresponding to the other
patches) similarly so all three cases assert queue_issues()/apply()
interactions.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@refactron/cli/analysis.py`:
- Around line 285-287: The code builds _project_root from the raw target (using
_target_path.parent) which makes nested targets persist the session under the
nested folder; replace that logic with the existing project-root detection
helper used elsewhere (call that helper with the provided target/_target_path to
compute the true repository root) and pass the returned root into
RefactronPipeline(project_root=...) so sessions are persisted under the
repository root; apply the same replacement for the other occurrence around
lines 312-313 (i.e., stop using _target_path.parent and use the shared
project-root helper instead).

In `@refactron/cli/refactor.py`:
- Around line 494-495: The current code unconditionally marks a session
ROLLED_BACK and removes the active session file after calling
BackupManager.rollback_session(), which can return partial failures; change the
logic in the block around _resolved_id (and the similar block at lines ~509-513)
to inspect the result of BackupManager.rollback_session() and only (1) set the
session state to ROLLED_BACK and (2) delete .refactron/current when
rollback_session reports all restores succeeded; if rollback_session reports any
failures, leave the session state unchanged (or set an explicit PARTIAL_ROLLBACK
status if available) and do not remove .refactron/current unless _resolved_id
matches the currently active session and the rollback fully succeeded; reference
functions/vars: BackupManager.rollback_session(), _resolved_id,
pipeline_session_id, _store.get_current_id(), and the ROLLED_BACK state to
locate and update the code paths.
- Around line 306-312: The new session-aware branch constructs RefactronPipeline
using _target_path/_project_root and returns early, which bypasses
_load_config(), the safety_level mapping, and flags like --config, --profile,
and --environment; update the flow so that before creating or returning the
RefactronPipeline instance (_pipeline) you call _load_config() and apply the
resolved configuration and safety_level (or pass them into RefactronPipeline
constructor) so the session-aware path honors --config, --profile, --environment
and --safety-level exactly like the original branch did.
- Around line 348-352: The call to _pipeline.apply(...) is missing the preview
argument so the CLI's preview flag is ignored (causing autofix to write
changes); update the two places where _pipeline.apply is invoked (the call using
_pipeline_session and the similar block further down) to pass preview=preview
along with dry_run=dry_run and verify=verify so the
RefactronPipeline.apply(preview, dry_run, verify, ...) safety-first flow
(preview → backup → apply → optional rollback) is preserved.

---

Outside diff comments:
In `@refactron/cli/analysis.py`:
- Around line 220-236: The JSON output branch currently prints payload and calls
raise SystemExit before the session persistence logic runs, which prevents
--fix-on from queuing fixes and stops the current session from being written;
move the session save/queueing code (the session persistence logic used
elsewhere in this file) to execute before the JSON branch's SystemExit so that
regardless of output_format (including the other JSON block at lines ~304-323)
the code that enqueues fixes and writes the current session runs prior to
exiting; ensure you reference and invoke the same session persistence routine
used by the normal output path and then keep the click.echo(_json.dumps(payload,
indent=2)) and raise SystemExit(1 if summary["critical"] > 0 else 0) after that.

---

Duplicate comments:
In `@refactron/cli/refactor.py`:
- Around line 309-315: The session and backup lookup currently use the caller
cwd or _target_path.parent instead of the pipeline's project root; change
construction of SessionStore and BackupManager to use the RefactronPipeline
instance's project_root (use _pipeline.project_root) so
_pipeline.store.load(session_id) and any BackupManager operations resolve
against the actual project root. Update the creation points that build
SessionStore/BackupManager (the code around where RefactronPipeline is
instantiated and the separate block referenced at the other location) to pass
_pipeline.project_root rather than Path.cwd() or _target_path.parent.
- Around line 373-376: The undo hint printed when _applied > 0 uses the old flag
and sends users to backup-session rollback; update the console.print invocation
that builds the hint (where _pipeline_session.session_id is referenced) to show
the new flag name --pipeline-session instead of --session so the suggested
command is "refactron rollback --pipeline-session <session_id>" and points users
to the pipeline rollback flow.

In `@refactron/cli/status.py`:
- Around line 108-112: The rollback hint currently prints "refactron rollback
--session {session.session_id}" which is the backup-session flag; change it to
use the pipeline-session flag so the displayed pipeline session can be undone.
Update the string in the status display (where console.print is called for the
applied branch) to use "--pipeline-session {session.session_id}" instead of
"--session", ensuring the condition that prints when applied remains the same
(references: session.session_id, applied, the console.print call in status.py).
- Around line 39-67: Wrap calls to store.list_sessions(),
store.load(session_id), store.load_current(), and store.load_latest() in
try/except that catches OSError, UnicodeDecodeError, and TypeError at the CLI
boundary in status.py; on exception print a concise user-friendly error via
console.print (e.g., "Error reading session data: <brief msg>") and
return/non-zero exit so a traceback is not shown. Ensure both the list_sessions
branch and the session-loading branch around session_id use this error handling
so unreadable/corrupt files are handled uniformly.

In `@refactron/core/pipeline_session.py`:
- Around line 142-144: The constructor SessionStore.__init__ is missing a return
type annotation; add the explicit "-> None" to the __init__ signature in the
SessionStore class (the method that sets self.root_dir and self.sessions_dir and
references self.SESSIONS_DIR) so the method is fully typed and satisfies
disallow_untyped_defs under refactron.
- Around line 149-152: The save() implementation writes session JSON in-place
and can leave a truncated newest file; update save() (function save and helper
_session_path/sessions_dir) to write atomically by writing to a temporary file
in the same sessions_dir (e.g., session_id + ".tmp" or use a temp name), fsync
the file, then os.replace/rename to the final path to ensure an atomic swap;
then modify load_latest() to iterate session files from newest to oldest (by
mtime or lexicographic order), attempting to read and json.loads each file and
skipping any that raise JSON parse errors or IO errors until a valid session is
found (returning None only if none valid).
- Around line 146-147: Validate session_id before constructing file paths and
when loading JSON: in _session_path(session_id) ensure session_id contains only
a safe token (e.g., alphanumeric, hyphen/underscore) or normalize and reject any
value that would traverse directories (prevent characters like '/' or '..');
build the path only after validation (instead of directly using sessions_dir /
f"{session_id}.json"). In the load(...) method, after reading and parsing the
file, verify the parsed object's embedded session_id equals the requested
session_id and raise an error if it differs (do not return parsed data on
mismatch). Use the existing symbols sessions_dir, _session_path, and load to
locate where to add validation and the integrity check, and raise a clear
ValueError or custom exception when validation fails.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@refactron/cli/analysis.py`:
- Around line 292-304: When constructing the PipelineSession instance by hand,
explicitly set its lifecycle/status to SessionState.ANALYZED (or the dataclass
field name used for lifecycle, e.g., "status" or "state") so it matches
RefactronPipeline.analyze() behavior; update the PipelineSession(...) call in
analysis.py to include the lifecycle field with SessionState.ANALYZED and import
or reference SessionState where used (ensure you use the same enum member name
as in RefactronPipeline.analyze to keep readers and status checks consistent).
- Around line 100-106: The --fix-on flag is parsed but never used when saving
the queued session; modify the call to queue_issues so it respects the parsed
fix_on threshold by passing the computed minimum severity (from _FIX_LEVEL_MAP
using the fix_on value, e.g., _FIX_LEVEL_MAP[fix_on.upper()] when fix_on is not
None) as the min_level argument to queue_issues(_pipeline_session, _all_issues,
min_level=...), and ensure the same change is applied to the other code path(s)
mentioned (lines ~280-309) where queue_issues is invoked so the saved session
actually filters issues by the user-specified level.

In `@refactron/cli/refactor.py`:
- Around line 529-559: The rollback branch currently triggers as soon as
_resolved_id is set (via pipeline_session_id or SessionStore.get_current_id()),
which runs before handling explicit rollback modes like --list, --clear,
--use-git or legacy positional IDs; move or guard this logic so it only executes
when the user actually requested a rollback action (e.g., when a specific
rollback flag/mode is set), not merely when an active session exists: modify the
control flow around _resolved_id, SessionStore, and the block that uses
BackupManager.rollback_session so that flag checks for
list/clear/use-git/positional-id are evaluated first and only when none apply
and the explicit rollback mode is present do you load the session, validate
backup_session_id, prompt for confirmation, and call
BackupManager.rollback_session; ensure functions/classes referenced are
SessionStore, _resolved_id/pipeline_session_id, BackupManager.rollback_session,
and _pipeline_session are used in the guarded branch.
- Around line 354-364: The current loop mutates stored session items (setting
_item.status = _FixStatus.SKIPPED) which persists the --fix-on filter; instead
leave _pipeline_session.fix_queue unchanged and apply the threshold only
transiently. Replace the in-place mutation with logic that computes a local view
or predicates: use _LEVEL_RANK, _threshold and _FixStatus to count pending items
whose level meets the threshold (e.g., count items where item.status ==
_FixStatus.PENDING and _LEVEL_RANK.get(item.level.upper(),0) >= _threshold) and
pass that filtered/local view into the apply step or consumer; do not write back
SKIPPED into _pipeline_session.fix_queue. Ensure all references to
_pending_count and any downstream use operate on the transient/filtered view
rather than mutated stored items.

In `@refactron/core/pipeline.py`:
- Around line 12-24: The import block in refactron/core/pipeline.py is not
sorted per repository conventions; re-run isort (profile='black') on this module
to reorder the imports (the block importing AutoFixEngine, FixRiskLevel,
BackupManager, CodeIssue, IssueCategory, IssueLevel, FixQueueItem, FixStatus,
PipelineSession, SessionState, SessionStore, RefactronConfig, and Refactron) so
they follow the project's isort/black profile ordering and satisfy pre-commit.

---

Duplicate comments:
In `@refactron/cli/analysis.py`:
- Around line 287-289: The current logic sets _project_root from Path(target) or
its parent which places the session (.refactron) under a selected subdirectory;
update this to resolve and use the repository root instead so sessions persist
at the real project root. Replace the _project_root computation used to
construct RefactronPipeline(project_root=_project_root) with code that finds the
repo root (e.g., walk parents from Path(target).resolve() or call git to get the
top-level) and set _project_root to that repository root before instantiating
RefactronPipeline; reference and update the symbols _target_path, _project_root,
and the RefactronPipeline instantiation.

In `@refactron/cli/refactor.py`:
- Around line 411-415: The undo hint prints a legacy flag (--session) causing
the rollback to use the old backup-session flow; update the printed command in
the block that checks `_applied > 0` (where `console.print` references
`_pipeline_session.session_id`) to use `--pipeline-session` instead of
`--session` so the hint points to the new pipeline rollback path.
- Around line 547-551: The code unconditionally marks the pipeline session as
rolled back and clears the current pointer after calling
_bm.rollback_session(_pipeline_session.backup_session_id); change this to
inspect the returned values (_restored_count, _failed) and only set
_pipeline_session.state = SessionState.ROLLED_BACK, call
_store.save(_pipeline_session), and _store.clear_current() when the rollback
completed without failures (e.g., _failed == 0 or similar success condition);
otherwise leave the session state unchanged (or set an appropriate
FAILED_ROLLBACK state) and persist that outcome so partial restores aren't
treated as successful.
- Around line 383-387: The apply call on _pipeline is only forwarding dry_run
and verify, so the preview flag is ignored and running the command with default
preview=True still performs an actual apply; update the _pipeline.apply
invocation(s) (reference: _pipeline.apply and _pipeline_session) to also accept
and forward the preview/autofix flag (e.g., preview=preview or preview=not
autofix depending on variable names) so the pipeline honors preview mode, and
make the same change for the other similar call block around the _pipeline.apply
at the 393-404 region.
- Around line 318-320: The pipeline project root is computed into _project_root
and passed to RefactronPipeline(project_root=_project_root) but SessionStore and
BackupManager are still rooted off Path.cwd() or Path(target).parent in other
flows (autofix, rollback), causing resumed sessions/backups to be looked up in
the wrong workspace; update the code that constructs SessionStore and
BackupManager (and any uses in autofix and rollback handlers) to derive their
base directory from the pipeline's project_root (e.g., use
RefactronPipeline.project_root or the local _project_root variable) instead of
hard-coding Path.cwd() or Path(target).parent—also apply the same change to the
other occurrence noted (lines 529-547) so all session/backup operations
consistently use the pipeline project root.
- Around line 315-320: The session-aware branch currently constructs
RefactronPipeline without loading command config or applying CLI flags, so call
_load_config() before returning and map CLI options (--config, --profile,
--environment, --safety-level) into the session flow; ensure RefactronPipeline
is instantiated with the selected risk level (pass the mapped FixRiskLevel value
instead of relying on the default) and preserve any config-derived settings when
creating _pipeline using _project_root/_target_path so the session path respects
config and safety flags.

In `@refactron/core/pipeline.py`:
- Around line 140-178: The code creates a backup session but never actually
copies files before calling fix_engine.fix_file, so create per-file backups
immediately after obtaining backup_session_id (use
backup_manager.create_backup_session and backup_manager.backup_dir) and before
calling fix_engine.fix_file; then call
BackupManager.validate_backup_integrity(session.backup_session_id) to get
(valid_paths, corrupt_paths) and if any corrupt_paths exist mark the
corresponding FixItem(s) as BLOCKED with block_reason and add them to
session.blocked_fixes, only proceeding to call fix_engine.fix_file for files
whose backups validated; ensure session.backup_session_id remains set and
item.backup_path points to backup_manager.backup_dir / backup_session_id /
file_path.name for applied items.
- Around line 97-123: queue_issues() is truncating and altering CodeIssue data
(storing only a reduced FixQueueItem and probing fixers with a dummy "x = 1\n"
in _find_fixer_name()), causing mismatches when _queue_items_to_issues()
reconstructs issues and apply() sees different payloads; fix by persisting the
full original issue payload (serialize the entire CodeIssue) into the queue item
instead of losing fields, change _find_fixer_name() to probe fixers using the
actual issue source/content (or skip probing and record candidate fixer names
without mutating payload), and ensure _queue_items_to_issues() deserializes and
restores the original IssueCategory and all fields so apply(), FixEngine.fixers,
and FixStatus logic operate on the exact analyzer-produced CodeIssue throughout.